﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq; 
using NTTDATA.BEENChina.ResultCertification.Config;
using NTTDATA.BEENChina.ResultCertification.Result;

namespace NTTDATA.BEENChina.ResultCertification.Checker.Date
{
    //TODO: 修改，    A-E工程有不相同的付签出现，并且其中包含[15][22][30]中的任意一个时
                      //抽出检证

                    //条件更正
                    //1.最终纳品付签不是15与22，并且A-E工程有不相同的付签出现，并且其中包含[15][22][30]中的任意一个时抽出
                    //2.E付签是15，E前面最后一个工程付签不是15时抽出
                    //3.E付签是22，E前面最后一个工程付签不是22时抽出 

    [Serializable]
    [VerfityAttribute(Id = "VerfityRq0229", Name = "付笺检证_A-E工程付笺不同且包含特定值", CategoryType = EnumCategoryType.日期, Model = true)]
    public class VerfityRq0229 : VerfityOneResult
    {

        string _commons = string.Empty;

        [Category("设定付笺包含的特定值"), Description("逗号分隔的特定值,如：15,22,30")]
        //[EditorAttribute(typeof(PropertyGridRichText), typeof(System.Drawing.Design.UITypeEditor))]
        public String Commons
        {
            get { return _commons; }
            set { _commons = value; }
        }

        /// <summary>
        /// 1.最终纳品付签不是15与22，并且A-E工程有不相同的付签出现，并且其中包含[15][22][30]中的任意一个时抽出
        /// 2.E付签是15，E前面最后一个工程付签不是15时抽出
        /// 3.E付签是22，E前面最后一个工程付签不是22时抽出
        /// </summary>
        /// <returns></returns>
        public override bool Check()
        {
            //要检验的特定值没设置
            if (String.IsNullOrEmpty(_commons.Trim() ))
            {
                return false;
            }

            bool bResult = false;

            Dictionary<EnumRank, string> entryCommons = null;
            //List<string> entryCommons = null;

            foreach (int i in Enum.GetValues(typeof(EnumRank)))
            {
                EnumRank rank = (EnumRank)i;
                

                if ((VerfityRanks & rank) == rank)
                {
                    if (ChildImageObject != null &&
                        ChildImageObject.OperatorEntryResults != null &&
                        ChildImageObject.OperatorEntryResults.Count(t => t.Rank == rank) > 0)
                    {
                        var operResult = ChildImageObject.OperatorEntryResults.Single(t => t.Rank == rank);

                        
                            string entryCommon = operResult.EntryCommon;

                            if (entryCommons == null)
                                entryCommons = new Dictionary<EnumRank, string>();
 
                            //&& !entryCommon.Equals("0") 
                            //2013-12-10 0付签也算
                            if (!String.IsNullOrEmpty(entryCommon))
                            {
                                entryCommons.Add(rank,entryCommon);
                            }
                        
                    }
                }

            }

            bResult = CheckA(entryCommons);

            if (!bResult)
            {
                bResult = CheckB(entryCommons);
            }


            if (bResult)
            {
                System.Console.WriteLine("VerfityRq0229");
              
            }
            return bResult;
        }

        /// <summary>
        /// 1.最终纳品付签不是15与22，并且A-E工程有不相同的付签出现，并且其中包含[15][22][30]中的任意一个时抽出
        /// 2.E付签是22，E前面最后一个工程付签不是22时抽出
        /// </summary>
        /// <param name="entryCommons"></param>
        /// <returns></returns>
        private bool CheckA(Dictionary<EnumRank, string> entryCommons)
        {
             

            bool bResult = false;
            if (entryCommons != null)
            {
                if (entryCommons.Count(t => t.Key == EnumRank.Final) > 0)
                {
                   string finalCommon = entryCommons.Single(t => t.Key == EnumRank.Final).Value;

                   if (finalCommon.Equals("15") || finalCommon.Equals("22"))
                   {
                       return false;
                   }
                }

                var _connonArray = _commons.Split(',').ToList();

                var allCommons = entryCommons.Select(t => t.Value).ToList();

                if (  allCommons.Any())
                {
                    if (allCommons.OrderBy(t => t).Distinct().Count() > 1)
                    {
                        allCommons.ForEach(t =>
                                               {

                                                   if (!bResult && t != null)
                                                   {
                                                       bResult = _connonArray.Contains(t);
                                                   }

                                               });
                    }
                }
            }

            return bResult;
        }

        /// <summary>
        /// 2.E付签是15，E前面最后一个工程付签不是15时抽出
        /// 2.E付签是22，E前面最后一个工程付签不是22时抽出
        /// </summary>
        /// <param name="entryCommons"></param>
        /// <returns></returns>
        private bool CheckB(Dictionary<EnumRank, string> entryCommons)
        {
            
              bool bResult = false;
              if (entryCommons != null)
              {
                  //remove final comm
                  //entryCommons.Remove(EnumRank.Final);
             
                  if ( ChildImageObject.OperatorEntryResults.Count(t => t.Rank == EnumRank.E) > 0)
                  {
                      if (entryCommons.Count(t => t.Key == EnumRank.Final) > 0)
                      {
                          string eCommon = entryCommons.Single(t => t.Key == EnumRank.Final).Value;

                          if (eCommon.Equals("15"))
                          {

                              var descCommon = entryCommons.OrderByDescending(t => t.Key).ToList();

                              if (descCommon.Count > 2)
                              {
                                  string lastCommon = descCommon.First(t => t.Key != EnumRank.Final && t.Key != EnumRank.E).Value;

                                  if (!lastCommon.Equals("15"))
                                  {
                                      bResult = true;
                                  }
                              }
                          }
                          else if (eCommon.Equals("22"))
                          {

                              var descCommon = entryCommons.OrderByDescending(t => t.Key).ToList();

                              if (descCommon.Count > 2)
                              {
                                  string lastCommon = descCommon.First(t => t.Key != EnumRank.Final && t.Key != EnumRank.E).Value;

                                  if (!lastCommon.Equals("22"))
                                      bResult = true;

                                  /*if (!descCommon[1].Value.Equals("22"))
                                  {
                                      bResult = true;
                                  }*/
                              }
                          }
                      }
                  }
              }

            return bResult;
        }


    }
}